Computing Integer Powers in Floating-Point Arithmetic

We introduce two algorithms for accurately evaluating powers to a positive integer in floating-point arithmetic, assuming a fused multiply-add (fma) instruction is available. We show that our log-time algorithm always produce faithfully-rounded results, discuss the possibility of getting correctly rounded results, and show that results correctly rounded in double precision can be obtained if extended-precision is available with the possibility to round into double precision (with a single rounding).Comment: Laboratoire LIP : CNRS/ENS Lyon/INRIA/Universit\'e Lyon

Choosing Starting Values for certain Newton-Raphson Iterations

Adresse de la revue : http://www.elsevier.com/wps/find/journaldescription.cws_home/505625/description#descriptionWe aim at finding the best possible seed values when computing $a^{\frac1p}$ using the Newton-Raphson iteration in a given interval. A natural choice of the seed value would be the one that best approximates the expected result. It turns out that in most cases, the best seed value can be quite far from this natural choice. When we evaluate a monotone function $f(a)$ in the interval $[a_{\min},a_{\max}]$, by building the sequence $x_n$ defined by the Newton-Raphson iteration, the natural choice consists in choosing $x_0$ equal to the arithmetic mean of the endpoint values. This minimizes the maximum possible distance between $x_0$ and $f(a)$. And yet, if we perform $n$ iterations, what matters is to minimize the maximum possible distance between $x_n$ and $f(a)$. In several examples, the value of the best starting point varies rather significantly with the number of iterations

Leading Guard Digits in Finite-Precision Redundant Representations

Redundant number representations are generally used to allow constant time additions, based on the fact that only bounded carry-ripples take place. But, carries may ripple out into positions which may not be needed to represent the final value of the result and, thus, a certain amount of leading guard digits are needed to correctly determine the result. Also, when cancellation during subtractions occurs, there may be nonzero digits in positions not needed to represent the result of the calculation. It is shown here that, for normal redundant digit sets with radix greater than two, a single guard digit is sufficient to determine the value of such an arbitrary length prefix of leading nonzero digits. This is also the case for the unsigned carry-save representation, whereas two guard digits are sufficient, and may be necessary, for additions in the binary signed-digit and 2's complement carry-save representations. Thus, only the guard digits need to be retained during sequences of additions and subtractions. At suitable points, the guard digits may then be converted into a single digit, representing the complete prefix

Guest Editors' Introduction: Special Section on Computer Arithmetic

International audienceCOMPUTER arithmetic is the mother of all computer research and application topics, like mathematics (as the title of a famous book by E.T. Bell) is the queen and servant of sciences and arithmetic the queen of mathematics. The etymology itself of the word computer is intrinsically related to the concept of arithmetic and mathematics. Interesting to note is that the origin of the word computer comes from the Latin word computare, which is defined as count, evaluate, calculate the result. In all cases, the connection between computers and computer arithmetic goes beyond simple etymology reasons. Computers are designed either to perform a specific calculation or to have extensive programmability for many changing tasks. In either case, at a certain level this translates into doing computations and arithmetic evaluations

Computing Correctly Rounded Integer Powers in Floating-Point Arithmetic

23 pagesWe introduce several algorithms for accurately evaluating powers to a positive integer in floating-point arithmetic, assuming a fused multiply-add (fma) instruction is available. We aim at always obtaining correctly-rounded results in round-to-nearest mode, that is, our algorithms return the floating-point number that is nearest the exact value